/**
 * @(#)RolesManagerK.java Nov 9, 2006
 *
 * Copyright (c) 2005-2010 Psiqueware S.A. de C.V. All Rights Reserved.
 * This software is the proprietary information Psiqueware S.A. de C.V.
 * Use is subject to license terms.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
 * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *
 * <br/>Usuario : AngelElectrico
 * <br/>Creaci&oacute;n: Nov 9, 2006 - 5:42:23 PM
 * <br/>
 * <br/>
 * <br/><t5>Cambios :</t5>
 * <br/><b>Fecha | Autor  |  Cambios</b>
 * <ul>
 * <li>Nov 9, 2006 | <a href = "mailto:AngelElectrico@PsiqueWare.com">Angel El&eacute;ctrico</a> | Creaci&oacute;n del Objeto.</li>
 * <li>Ene 23, 2007 | <a href = "mailto:AngelElectrico@PsiqueWare.com">Angel El&eacute;ctrico</a> | Se cambian los mensajes de error al nuevo formato UML.</li>
 * <li>Ene 25, 2007 | <a href = "mailto:AngelElectrico@PsiqueWare.com">Angel El&eacute;ctrico</a> | Se resolvi&oacute; el problema de la transaccionalidad truca por las excepciones de par&aacute;metros..</li>
 * </ul>
 */

package com.psiqueware.alheli.seguridad.manager;

import com.psiqueware.alheli.dao.DAOException;
import com.psiqueware.alheli.dao.EnlaceTransaccional;
import com.psiqueware.alheli.exception.NullArgumentException;
import com.psiqueware.alheli.exception.NullConditionException;
import com.psiqueware.alheli.logging.Logger;
import com.psiqueware.alheli.logging.LoggerFactory;
import com.psiqueware.alheli.manager.BaseManager;
import com.psiqueware.alheli.seguridad.*;
import com.psiqueware.alheli.seguridad.dao.RegistroPermisoDAO;
import com.psiqueware.alheli.seguridad.dao.SeguridadDAOFactory;
import com.psiqueware.alheli.seguridad.modelo.*;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * Controla la seguridad dentro de los {@link Rol}es.
 * Permite dar de alta o de baja los {@link Permiso} de los {@link Rol}.
 * Permite dar de alta o de baja los {@link Rol} de los {@link Credencial}.
 * <br/>Paquete Original: com.psiqueware.basico.seguridad.manager
 * <br/>Nombre  Original: SeguridadModulosTManagerK
 * <br/>Oprima para ver : <a href="RolesManagerK.java.html"><i>C&oacute;digo Fuente</i> </a>
 *
 * @author <a href="mailto:AngelElectrico@PsiqueWare.com">Angel El&eacute;ctrico</a>
 * @version Revision: 1.1 Nov 9, 2006 5:42:23 PM
 * @noinspection StaticMethodReferencedViaSubclass, DuplicateStringLiteralInspection, ClassWithoutToString, ClassWithoutNoArgConstructor, SuppressionAnnotation, CastToConcreteClass
 */
public final class RolesManagerK extends BaseManager implements RolesManager
{

    /**
     * Logger de clase para RolesManagerK
     */
    private static final Logger s_log = LoggerFactory.getLogger(RolesManagerK.class);

    /**
     * {@link Map} de {@link RegistroPermiso} con los {@link Permiso} disponibles.
     */
    private Map<String, RegistroPermiso> m_registros = new HashMap<String, RegistroPermiso>();

    /**
     * Registramos los {@link Permiso}s por defecto.
     */
    static
    {
        final RolesManagerK rolesManagerK = new RolesManagerK();
        final EnlaceTransaccional enlaceTransaccional = rolesManagerK.nuevoEnlace();
        try
        {
            enlaceTransaccional.iniciaTransaccion();
            rolesManagerK.registraPermiso(Agrupacion.PERMISO, "Permiso de edici&oacute;n de agrupaciones.", enlaceTransaccional);
            rolesManagerK.registraPermiso(Credencial.PERMISO, "Permiso de edici&oacute;n de credenciales.", enlaceTransaccional);
            rolesManagerK.registraPermiso(Rol.PERMISO, "Permiso de edici&oacute;n de roles.", enlaceTransaccional);
            rolesManagerK.registraPermiso(UsuariosSeguridadManager.PERMISO, "Permiso de administraci&oacute;n de UsuarioSeguridad.", enlaceTransaccional);
        }
        catch (final SeguridadException e)
        {
            final String error = "<error><msg>No se pudier&oacute;n registrar los Roles por defecto.</msg></error>";
            s_log.error(error);
            s_log.error(e);
            enlaceTransaccional.rollBack();
            throw new RuntimeException(error, e);
        }
        finally
        {
            enlaceTransaccional.finalizaTransaccion();
        }
    }

    /**
     * Registra un {@link Permiso} en la seguridad para poder ser utilizado.
     *
     * @param permiso             {@link Permiso} a registrar.
     * @param descripcion         Descripci&oacute;n del {@link Permiso}.
     * @param enlaceTransaccional enlace para hacer at&oacute;micas las transacciones.
     *
     * @throws com.psiqueware.alheli.seguridad.SeguridadException en caso de un error de acceso a persistencia.
     */
    @Override
    public void registraPermiso(final Permiso permiso, final String descripcion, final EnlaceTransaccional enlaceTransaccional) throws SeguridadException
    {
        if (null == permiso)
            throw new NullArgumentException("<error>El argumento 'permiso' no puede ser NULL.</error>");
        listaPermisosRegistrados(enlaceTransaccional);
        final String nombrePermiso = permiso.getNombrePermiso();
        RegistroPermiso registroPermiso = m_registros.get(nombrePermiso);
        try
        {
            if (null == registroPermiso)
            {
                registroPermiso = new RegistroPermisoK(permiso, descripcion);
                SeguridadDAOFactory.findDAORegistroPermiso(enlaceTransaccional).saveRegistroPermiso(registroPermiso, enlaceTransaccional);
                m_registros.put(nombrePermiso, registroPermiso);
            }
            else if (registroPermiso.getDescripcion().equals(descripcion))
            {
            }
            else
            {
                final RegistroPermisoK rpK = (RegistroPermisoK) registroPermiso;
                rpK.setNombrePermiso(nombrePermiso);
                rpK.setDescripcion(descripcion);
                SeguridadDAOFactory.findDAORegistroPermiso(enlaceTransaccional).updateRegistroPermiso(registroPermiso, enlaceTransaccional);
            }
        }
        catch (final DAOException e)
        {
            final String error = "<error><msg>No se pudo guardar el RegistroPermiso.</msg><parametros>" + registroPermiso + "</parametros></error>";
            s_log.error(error);
            s_log.error(e);
            enlaceTransaccional.rollBack();
            throw new SeguridadException(error, e);
        }
    }

    /**
     * Devuelve un listado de {@link Permiso} registrados.
     *
     * @param enlaceTransaccional enlace para hacer at&oacute;micas las transacciones.
     *
     * @return {@link java.util.List} de {@link Permiso}.
     *
     * @throws com.psiqueware.alheli.seguridad.SeguridadException en caso de un error de acceso a persistencia.
     */
    @Override
    public List<Permiso> listaPermisosRegistrados(final EnlaceTransaccional enlaceTransaccional) throws SeguridadException
    {
        final List<Permiso> permisos = new ArrayList<Permiso>();
        if (m_registros.isEmpty())
        {
            try
            {
                List<RegistroPermiso> registros = SeguridadDAOFactory.findDAORegistroPermiso(enlaceTransaccional).listRegistroPermiso(enlaceTransaccional);
                for (final RegistroPermiso registro : registros)
                {
                    m_registros.put(registro.getNombrePermiso(), registro);
                    permisos.add(registro.toPermiso());
                }
            }
            catch (DAOException e)
            {
                final String error = "<error><msg>No se pudo cargar el listado de RegistroPermiso.</msg></error>";
                s_log.error(error);
                s_log.error(e);
                enlaceTransaccional.rollBack();
                throw new SeguridadException(error, e);
            }
        }
        return permisos;
    }

    /**
     * A&ntilde;ade un {@link Rol} a un {@link Credencial} dado.
     * Y persiste los cambios.
     *
     * @param enlaceTransaccional enlace para hacer at&oacute;micas las transacciones.
     * @param rol                 a agregar.
     * @param usuarioDestino      {@link UsuarioSeguridad} al que se le va a agregar el {@link Rol}.
     * @param autoriza            {@link UsuarioSeguridad} que autoriza la operaci&oacute;n.
     *
     * @return <code>true</code> si la operaci&oacute;n se realiz&oacute; exitosamente; <code>false</code> en caso contrario.
     *
     * @throws com.psiqueware.alheli.seguridad.SeguridadException en caso de no poder completar la operaci&oacute;n.
     * @noinspection CastToConcreteClass
     */
    public boolean addRolUsuario(final Rol rol, UsuarioSeguridad usuarioDestino, final UsuarioSeguridad autoriza, final EnlaceTransaccional enlaceTransaccional) throws SeguridadException
    {
        try
        {
            //Validamos
            if (null == rol) throw new NullArgumentException("<error>El argumento 'rol' no puede ser NULL.</error>");
            if (null == rol.getId())
                throw new IllegalArgumentException("<error>El argumento 'rol' deb&iacute;a encontrarse previamente persistido.</error>");
            if (null == usuarioDestino)
                throw new NullArgumentException("<error>El argumento 'usuarioDestino' no puede ser NULL.</error>");
            if (null == usuarioDestino.getId())
                throw new IllegalArgumentException("<error>El argumento 'usuarioDestino' deb&iacute;a encontrarse previamente persistido.</error>");
            if (null == usuarioDestino.getCredencial()) throw new SeguridadNoInicializadaException();
            if (null == autoriza)
                throw new NullArgumentException("<error>El argumento 'autoriza' no puede ser NULL.</error>");
            if (null == autoriza.getId())
                throw new IllegalArgumentException("<error>El argumento 'autoriza' deb&iacute;a encontrarse previamente persistido.</error>");
            if (null == autoriza.getCredencial()) throw new SeguridadNoInicializadaException();

            //agregamos.
            CredencialK credencialK = (CredencialK) usuarioDestino.getCredencial();
            if (null == credencialK.getId())
                throw new IllegalArgumentException("<error>El argumento 'credencialK' deb&iacute;a encontrarse previamente persistido.</error>");

            boolean salida = false;
            if (autoriza.getCredencial().tienePermiso(Credencial.PERMISO) && credencialK.getAgrupacion().equals(rol.getAgrupacion()))
            {
                if (s_log.isDebugEnabled()) s_log.debug("Usuario autorizado");

                salida = credencialK.containsRol(rol);
                if (!salida)
                {
                    final RolCredencialK rolCredencialK = new RolCredencialK(rol, credencialK);
                    SeguridadDAOFactory.findDAORolCredencial(enlaceTransaccional).saveRolCredencial(rolCredencialK, enlaceTransaccional);
                    credencialK.addRolCredencial(rolCredencialK);
                }
            }

            return salida;
        }
        catch (Exception e)
        {
            String error = "<error><msg>No se pudo a&ntilde;adir el Rol a la Credencial en persistencia.</msg></error>";
            s_log.error(error);
            s_log.error(e);
            enlaceTransaccional.rollBack();
            throw new SeguridadException(error, e);
        }
    }

    /**
     * Remueve un {@link Rol} a un {@link Credencial} dado.
     * Y persiste los cambios.
     *
     * @param enlaceTransaccional enlace para hacer at&oacute;micas las transacciones.
     * @param rol                 a eliminar.
     * @param usuarioDestino      {@link UsuarioSeguridad} al que se le retir&oacute; el {@link Rol}.
     * @param autoriza            {@link UsuarioSeguridad} que autoriza la transacci&oacute;n.
     *
     * @return <code>true</code> si la operaci&oacute;n se realiz&oacute; exitosamente; <code>false</code> en caso contrario.
     *
     * @throws com.psiqueware.alheli.seguridad.SeguridadException en caso de no poder completar la operaci&oacute;n.
     * @noinspection CastToConcreteClass
     */
    public boolean removeRolUsuario(final Rol rol, UsuarioSeguridad usuarioDestino, final UsuarioSeguridad autoriza, final EnlaceTransaccional enlaceTransaccional) throws SeguridadException
    {
        try
        {
            //Validamos
            if (null == rol) throw new NullArgumentException("<error>El argumento 'rol' no puede ser NULL.</error>");
            if (null == rol.getId())
                throw new IllegalArgumentException("<error>El argumento 'rol' deb&iacute;a encontrarse previamente persistido.</error>");
            if (null == usuarioDestino)
                throw new NullArgumentException("<error>El argumento 'usuarioDestino' no puede ser NULL.</error>");
            if (null == usuarioDestino.getId())
                throw new IllegalArgumentException("<error>El argumento 'usuarioDestino' deb&iacute;a encontrarse previamente persistido.</error>");
            if (null == usuarioDestino.getCredencial()) throw new SeguridadNoInicializadaException();
            if (null == autoriza)
                throw new NullArgumentException("<error>El argumento 'autoriza' no puede ser NULL.</error>");
            if (null == autoriza.getId())
                throw new IllegalArgumentException("<error>El argumento 'autoriza' deb&iacute;a encontrarse previamente persistido.</error>");
            if (null == autoriza.getCredencial()) throw new SeguridadNoInicializadaException();

            //lo eliminamos.
            CredencialK credencialK = (CredencialK) usuarioDestino.getCredencial();
            boolean salida = false;
            if (autoriza.getCredencial().tienePermiso(Credencial.PERMISO))
            {
                if (s_log.isDebugEnabled()) s_log.debug(" Usuario autorizado");
                salida = credencialK.containsRol(rol);
                if (salida)
                {
                    final RolCredencial rolCredencial = credencialK.buscaRolCredencial(rol);
                    credencialK.removeRolCredencial(rolCredencial);
                    SeguridadDAOFactory.findDAORolCredencial(enlaceTransaccional).deleteRolCredencial(rolCredencial, enlaceTransaccional);
                }
            }
            return salida;
        }
        catch (Exception e)
        {
            String error = "<error><msg>No se pudo remover el Rol de la Credencial.</msg></error>";
            s_log.error(error);
            s_log.error(e);
            enlaceTransaccional.rollBack();
            throw new SeguridadException(error, e);

        }
    }

    /**
     * A&ntilde;ade un {@link Permiso} a un {@link Rol} dado.El rolPresidencial no se puede alterar.
     *
     * @param enlaceTransaccional enlace para hacer at&oacute;micas las transacciones.
     * @param permiso             a agregar.
     * @param rol                 al que se le va a agregar el {@link Permiso}.
     * @param autoriza            {@link UsuarioSeguridad} que autoriza la transacci&oacute;n.
     *
     * @return <code>true</code> si la operaci&oacute;n se fu&eacute; autorizada; <code>false</code> en caso contrario.
     *
     * @throws com.psiqueware.alheli.seguridad.SeguridadException en caso de no poder persistir los cambios.
     * @noinspection CastToConcreteClass
     */
    public boolean addPermisoRol(final Permiso permiso, Rol rol, final UsuarioSeguridad autoriza, final EnlaceTransaccional enlaceTransaccional) throws SeguridadException
    {
        try
        {
            //validamos
            if (null == permiso)
                throw new NullArgumentException("<error>El argumento 'permiso' no puede ser NULL.</error>");
            if (null == rol) throw new NullArgumentException("<error>El argumento 'rol' no puede ser NULL.</error>");
            if (null == rol.getId())
                throw new IllegalArgumentException("<error>El argumento 'rol' deb&iacute;a encontrarse previamente persistido.</error>");
            if (null == autoriza)
                throw new NullArgumentException("<error>El argumento 'autoriza' no puede ser NULL.</error>");
            if (null == autoriza.getId())
                throw new IllegalArgumentException("<error>El argumento 'autoriza' deb&iacute;a encontrarse previamente persistido.</error>");
            if (null == autoriza.getCredencial()) throw new SeguridadNoInicializadaException();

            //iniciamos
            RolK rolK = (RolK) rol;
            boolean salida = rolK.listPermisos().contains(permiso);
            if (autoriza.getCredencial().tienePermiso(Rol.PERMISO) && !salida)
            {
                salida = agregaPermisoSinSeguridad(permiso, rol, enlaceTransaccional);
            }
            return salida;
        }
        catch (Exception e)
        {
            String error = "<error><msg>No se pudieron persistir los cambios para a&ntilde;adir el permiso.</msg><parameter>" + rol + "</parameter></error>";
            s_log.error(error);
            s_log.error(e);
            enlaceTransaccional.rollBack();
            throw new SeguridadException(error, e);

        }
    }

    /**
     * Agrega un {@link Permiso} sin verificar por la autorizaci&oacute;n.
     * @param permiso {@link Permiso} a agregar.
     * @param rol {@link Rol} donde se va a agregar el {@link Permiso}.
     * @param enlaceTransaccional enlace para hacer at&oacute;micas las transacciones.
     * @return <code>true</code> si el Permiso se agrego; <code>false</code> en caso contrario.
     */
    public boolean agregaPermisoSinSeguridad(final Permiso permiso, final Rol rol, final EnlaceTransaccional enlaceTransaccional) throws DAOException
    {
        boolean salida=false;
        final RolK rolK = (RolK) rol;
        if (!rolK.listPermisos().contains(permiso))
        {
            salida=true;
            final RegistroPermisoDAO daoRegistroPermiso = SeguridadDAOFactory.findDAORegistroPermiso(enlaceTransaccional);
            RegistroPermiso registroPermiso = daoRegistroPermiso.findRegistroPermisoPorPermiso(permiso, enlaceTransaccional);
            if (null == registroPermiso)
                throw new NullConditionException("<error><msg>El 'registroPermiso' no existe para el permiso.</msg><parameter>" + permiso.getNombrePermiso() + "</parameter></error>");
            final PermisoRolK prK = new PermisoRolK(rol, registroPermiso);
            rolK.addPermisoRol(prK);
            SeguridadDAOFactory.findDAOPermisoRol(enlaceTransaccional).savePermisoRol(prK, enlaceTransaccional);
        }
        return salida;
    }

    /**
     * Remueve un {@link Permiso} a un {@link Rol} dado.El rolPresidencial no se puede alterar.
     *
     * @param permiso             a remover.
     * @param rol                 de donde se va a eliminar el permiso.
     * @param autoriza            {@link UsuarioSeguridad} que autoriza la transacci&oacute;n.
     * @param enlaceTransaccional enlace para hacer at&oacute;micas las transacciones.
     *
     * @return <code>true</code> si la operaci&oacute;n se realiz&oacute; exitosamente; <code>false</code> en caso contrario.
     *
     * @throws com.psiqueware.alheli.seguridad.SeguridadException en caso de un error de acceso a persistencia.
     * @noinspection CastToConcreteClass
     */
    public boolean removePermisoRol(final Permiso permiso, Rol rol, final UsuarioSeguridad autoriza, final EnlaceTransaccional enlaceTransaccional) throws SeguridadException
    {
        try
        {
            //validamos
            if (null == permiso)
                throw new NullArgumentException("<error>El argumento 'permiso' no puede ser NULL.</error>");
            if (null == rol) throw new NullArgumentException("<error>El argumento 'rol' no puede ser NULL.</error>");
            if (null == rol.getId())
                throw new IllegalArgumentException("<error>El argumento 'rol' deb&iacute;a encontrarse previamente persistido.</error>");
            if (null == autoriza)
                throw new NullArgumentException("<error>El argumento 'autoriza' no puede ser NULL.</error>");
            if (null == autoriza.getId())
                throw new IllegalArgumentException("<error>El argumento 'autoriza' deb&iacute;a encontrarse previamente persistido.</error>");
            if (null == autoriza.getCredencial()) throw new SeguridadNoInicializadaException();

            //iniciamos
            boolean salida = false;
            final RolK rolK = (RolK) rol;
            if (autoriza.getCredencial().tienePermiso(Rol.PERMISO) && rolK.getPermisos().contains(permiso))
            {
                final PermisoRol permisoRol = rolK.buscaPermisoRol(permiso);
                rolK.removePermisoRol(permisoRol);
                SeguridadDAOFactory.findDAOPermisoRol(enlaceTransaccional).deletePermisoRol(permisoRol, enlaceTransaccional);
                salida=true;
            }
            return salida;
        }
        catch (Exception e)
        {
            String error = "<error><msg>No se pudo remover el permiso del rol.</msg><parameter>" + rol + "</parameter></error>";
            s_log.error(error);
            s_log.error(e);
            enlaceTransaccional.rollBack();
            throw new SeguridadException(error, e);
        }
    }

    /**
     * Crea un nuevo {@link Rol} para una {@link Agrupacion} dada. Se encuentra persistido el {@link Rol} despu&eacute;s de
     * ejecutar esta operaci&oacute;n y es parte del {@link Agrupacion}.
     *
     * @param nombre              del {@link Rol}. No puede ser <code>null</code> ni vacio.
     * @param autoriza            {@link UsuarioSeguridad} que pretende autorizar la operaci&oacute;n. De &Eacute;l se toma el {@link Agrupacion} para el nuevo {@link Rol}.
     * @param enlaceTransaccional enlace para hacer at&oacute;micas las transacciones.
     *
     * @return {@link Rol} en caso de que la operaci&oacute;n fuera autorizada; <code>null</code> en caso contrario.
     *
     * @throws IllegalArgumentException                           si el rol que se quiere crear ya existe en el {@link Agrupacion}.
     * @throws com.psiqueware.alheli.seguridad.SeguridadException en caso de no poderse persistir los cambios.
     * @noinspection CastToConcreteClass, AssignmentToNull
     */
    public Rol nuevoRol(final String nombre, final UsuarioSeguridad autoriza, final EnlaceTransaccional enlaceTransaccional) throws SeguridadException
    {
        try
        {
            //validamos
            if (null == nombre)
                throw new NullArgumentException("<error>El argumento 'nombre' no puede ser NULL.</error>");
            if (0 == nombre.trim().length())
                throw new IllegalArgumentException("<error>El argumento 'nombre' es una cadena vacia.</error>");
            if (null == autoriza)
                throw new NullArgumentException("<error>El argumento 'autoriza' no puede ser NULL.</error>");
            if (null == autoriza.getId())
                throw new IllegalArgumentException("<error>El argumento 'autoriza' deb&iacute;a encontrarse previamente persistido.</error>");
            if (null == autoriza.getCredencial()) throw new SeguridadNoInicializadaException();

            //iniciamos
            Credencial credencial = autoriza.getCredencial();
            AgrupacionK agrupacionK = (AgrupacionK) credencial.getAgrupacion();
            if (agrupacionK.isRolRegistrado(nombre))
            {
                String error = "<error><msg>Un Rol con el mismo nombre (" + nombre + ") ya ha sido registrado para este agrupacion.</msg><parameter>" + agrupacionK + "</parameter></error>";
                s_log.error(error);
                enlaceTransaccional.rollBack();
                throw new IllegalArgumentException(error);
            }

            //Verificamos los permisos para crear este rolK
            boolean salida = false;
            RolK rolK = new RolK(agrupacionK, nombre);
            if (autoriza.getCredencial().tienePermiso(Agrupacion.PERMISO))
            {
                agrupacionK.addRol(rolK);
                salida = true;
            }

            //Si no fue autorizada la operaci&oacute;n eliminamos el RolK
            if (!salida)
            {
                rolK = null;
            }
            else //En otro caso Persistimos el nuevo Rol creado.
            {
                SeguridadDAOFactory.findDAORol(enlaceTransaccional).saveRol(rolK, enlaceTransaccional);
            }

            return rolK;
        }
        catch (Exception e)
        {
            String error = "<error><msg>No se pudo persistir en nuevo Rol.</msg><parameter>" + nombre + "</parameter></error>";
            s_log.error(error);
            s_log.error(e);
            enlaceTransaccional.rollBack();
            throw new SeguridadException(error, e);
        }
    }
}

